package com.reportgear.report.model.script;

// $ANTLR 3.2 Sep 23, 2009 12:02:23 D:\\antlr\\Expr.g 2010-01-27 21:34:16

import org.antlr.runtime.BaseRecognizer;
import org.antlr.runtime.CharStream;
import org.antlr.runtime.DFA;
import org.antlr.runtime.EarlyExitException;
import org.antlr.runtime.Lexer;
import org.antlr.runtime.MismatchedSetException;
import org.antlr.runtime.NoViableAltException;
import org.antlr.runtime.RecognitionException;
import org.antlr.runtime.RecognizerSharedState;

public class ExprLexer extends Lexer {
    public static final int NumberLiteral=9;
    public static final int T__23=23;
    public static final int T__22=22;
    public static final int T__21=21;
    public static final int T__20=20;
    public static final int SUB=5;
    public static final int Digit=12;
    public static final int EOF=-1;
    public static final int HexDigit=14;
    public static final int StringLiteral=8;
    public static final int T__19=19;
    public static final int DigitNoZero=13;
    public static final int WS=7;
    public static final int COLUMNROW=11;
    public static final int UnicodeEscape=15;
    public static final int PLUS=4;
    public static final int VAR=10;
    public static final int FUNCNAME=6;
    public static final int OctalEscape=16;
    public static final int EscapeSequence=17;
    public static final int BooleanLiteral=18;

    // delegates
    // delegators

    public ExprLexer() {;} 
    public ExprLexer(CharStream input) {
        this(input, new RecognizerSharedState());
    }
    public ExprLexer(CharStream input, RecognizerSharedState state) {
        super(input,state);

    }
    public String getGrammarFileName() { return "D:\\antlr\\Expr.g"; }

    // $ANTLR start "PLUS"
    public final void mPLUS() throws RecognitionException {
        try {
            int _type = PLUS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\Expr.g:3:6: ( '+' )
            // D:\\antlr\\Expr.g:3:8: '+'
            {
            match('+'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "PLUS"

    // $ANTLR start "SUB"
    public final void mSUB() throws RecognitionException {
        try {
            int _type = SUB;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\Expr.g:4:5: ( '-' )
            // D:\\antlr\\Expr.g:4:7: '-'
            {
            match('-'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SUB"

    // $ANTLR start "T__19"
    public final void mT__19() throws RecognitionException {
        try {
            int _type = T__19;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\Expr.g:5:7: ( '*' )
            // D:\\antlr\\Expr.g:5:9: '*'
            {
            match('*'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "T__19"

    // $ANTLR start "T__20"
    public final void mT__20() throws RecognitionException {
        try {
            int _type = T__20;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\Expr.g:6:7: ( '/' )
            // D:\\antlr\\Expr.g:6:9: '/'
            {
            match('/'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "T__20"

    // $ANTLR start "T__21"
    public final void mT__21() throws RecognitionException {
        try {
            int _type = T__21;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\Expr.g:7:7: ( '(' )
            // D:\\antlr\\Expr.g:7:9: '('
            {
            match('('); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "T__21"

    // $ANTLR start "T__22"
    public final void mT__22() throws RecognitionException {
        try {
            int _type = T__22;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\Expr.g:8:7: ( ')' )
            // D:\\antlr\\Expr.g:8:9: ')'
            {
            match(')'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "T__22"

    // $ANTLR start "T__23"
    public final void mT__23() throws RecognitionException {
        try {
            int _type = T__23;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\Expr.g:9:7: ( ',' )
            // D:\\antlr\\Expr.g:9:9: ','
            {
            match(','); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "T__23"

    // $ANTLR start "Digit"
    public final void mDigit() throws RecognitionException {
        try {
            // D:\\antlr\\Expr.g:106:7: ( '0' .. '9' )
            // D:\\antlr\\Expr.g:106:8: '0' .. '9'
            {
            matchRange('0','9'); 

            }

        }
        finally {
        }
    }
    // $ANTLR end "Digit"

    // $ANTLR start "DigitNoZero"
    public final void mDigitNoZero() throws RecognitionException {
        try {
            // D:\\antlr\\Expr.g:110:2: ( '1' .. '9' )
            // D:\\antlr\\Expr.g:110:4: '1' .. '9'
            {
            matchRange('1','9'); 

            }

        }
        finally {
        }
    }
    // $ANTLR end "DigitNoZero"

    // $ANTLR start "HexDigit"
    public final void mHexDigit() throws RecognitionException {
        try {
            // D:\\antlr\\Expr.g:114:10: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )
            // D:\\antlr\\Expr.g:114:12: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )
            {
            if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f') ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}


            }

        }
        finally {
        }
    }
    // $ANTLR end "HexDigit"

    // $ANTLR start "UnicodeEscape"
    public final void mUnicodeEscape() throws RecognitionException {
        try {
            // D:\\antlr\\Expr.g:118:5: ( '\\\\' 'u' HexDigit HexDigit HexDigit HexDigit )
            // D:\\antlr\\Expr.g:118:9: '\\\\' 'u' HexDigit HexDigit HexDigit HexDigit
            {
            match('\\'); 
            match('u'); 
            mHexDigit(); 
            mHexDigit(); 
            mHexDigit(); 
            mHexDigit(); 

            }

        }
        finally {
        }
    }
    // $ANTLR end "UnicodeEscape"

    // $ANTLR start "OctalEscape"
    public final void mOctalEscape() throws RecognitionException {
        try {
            // D:\\antlr\\Expr.g:124:5: ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) )
            int alt1=3;
            int LA1_0 = input.LA(1);

            if ( (LA1_0=='\\') ) {
                int LA1_1 = input.LA(2);

                if ( ((LA1_1>='0' && LA1_1<='3')) ) {
                    int LA1_2 = input.LA(3);

                    if ( ((LA1_2>='0' && LA1_2<='7')) ) {
                        int LA1_4 = input.LA(4);

                        if ( ((LA1_4>='0' && LA1_4<='7')) ) {
                            alt1=1;
                        }
                        else {
                            alt1=2;}
                    }
                    else {
                        alt1=3;}
                }
                else if ( ((LA1_1>='4' && LA1_1<='7')) ) {
                    int LA1_3 = input.LA(3);

                    if ( ((LA1_3>='0' && LA1_3<='7')) ) {
                        alt1=2;
                    }
                    else {
                        alt1=3;}
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 1, 1, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 1, 0, input);

                throw nvae;
            }
            switch (alt1) {
                case 1 :
                    // D:\\antlr\\Expr.g:124:9: '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' )
                    {
                    match('\\'); 
                    // D:\\antlr\\Expr.g:124:14: ( '0' .. '3' )
                    // D:\\antlr\\Expr.g:124:15: '0' .. '3'
                    {
                    matchRange('0','3'); 

                    }

                    // D:\\antlr\\Expr.g:124:25: ( '0' .. '7' )
                    // D:\\antlr\\Expr.g:124:26: '0' .. '7'
                    {
                    matchRange('0','7'); 

                    }

                    // D:\\antlr\\Expr.g:124:36: ( '0' .. '7' )
                    // D:\\antlr\\Expr.g:124:37: '0' .. '7'
                    {
                    matchRange('0','7'); 

                    }


                    }
                    break;
                case 2 :
                    // D:\\antlr\\Expr.g:125:9: '\\\\' ( '0' .. '7' ) ( '0' .. '7' )
                    {
                    match('\\'); 
                    // D:\\antlr\\Expr.g:125:14: ( '0' .. '7' )
                    // D:\\antlr\\Expr.g:125:15: '0' .. '7'
                    {
                    matchRange('0','7'); 

                    }

                    // D:\\antlr\\Expr.g:125:25: ( '0' .. '7' )
                    // D:\\antlr\\Expr.g:125:26: '0' .. '7'
                    {
                    matchRange('0','7'); 

                    }


                    }
                    break;
                case 3 :
                    // D:\\antlr\\Expr.g:126:9: '\\\\' ( '0' .. '7' )
                    {
                    match('\\'); 
                    // D:\\antlr\\Expr.g:126:14: ( '0' .. '7' )
                    // D:\\antlr\\Expr.g:126:15: '0' .. '7'
                    {
                    matchRange('0','7'); 

                    }


                    }
                    break;

            }
        }
        finally {
        }
    }
    // $ANTLR end "OctalEscape"

    // $ANTLR start "EscapeSequence"
    public final void mEscapeSequence() throws RecognitionException {
        try {
            // D:\\antlr\\Expr.g:131:5: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | UnicodeEscape | OctalEscape )
            int alt2=3;
            int LA2_0 = input.LA(1);

            if ( (LA2_0=='\\') ) {
                switch ( input.LA(2) ) {
                case '\"':
                case '\'':
                case '\\':
                case 'b':
                case 'f':
                case 'n':
                case 'r':
                case 't':
                    {
                    alt2=1;
                    }
                    break;
                case 'u':
                    {
                    alt2=2;
                    }
                    break;
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                    {
                    alt2=3;
                    }
                    break;
                default:
                    NoViableAltException nvae =
                        new NoViableAltException("", 2, 1, input);

                    throw nvae;
                }

            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 2, 0, input);

                throw nvae;
            }
            switch (alt2) {
                case 1 :
                    // D:\\antlr\\Expr.g:131:9: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' )
                    {
                    match('\\'); 
                    if ( input.LA(1)=='\"'||input.LA(1)=='\''||input.LA(1)=='\\'||input.LA(1)=='b'||input.LA(1)=='f'||input.LA(1)=='n'||input.LA(1)=='r'||input.LA(1)=='t' ) {
                        input.consume();

                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;}


                    }
                    break;
                case 2 :
                    // D:\\antlr\\Expr.g:132:9: UnicodeEscape
                    {
                    mUnicodeEscape(); 

                    }
                    break;
                case 3 :
                    // D:\\antlr\\Expr.g:133:9: OctalEscape
                    {
                    mOctalEscape(); 

                    }
                    break;

            }
        }
        finally {
        }
    }
    // $ANTLR end "EscapeSequence"

    // $ANTLR start "BooleanLiteral"
    public final void mBooleanLiteral() throws RecognitionException {
        try {
            int _type = BooleanLiteral;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\Expr.g:136:16: ( 'true' | 'false' )
            int alt3=2;
            int LA3_0 = input.LA(1);

            if ( (LA3_0=='t') ) {
                alt3=1;
            }
            else if ( (LA3_0=='f') ) {
                alt3=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 3, 0, input);

                throw nvae;
            }
            switch (alt3) {
                case 1 :
                    // D:\\antlr\\Expr.g:136:20: 'true'
                    {
                    match("true"); 


                    }
                    break;
                case 2 :
                    // D:\\antlr\\Expr.g:136:27: 'false'
                    {
                    match("false"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "BooleanLiteral"

    // $ANTLR start "StringLiteral"
    public final void mStringLiteral() throws RecognitionException {
        try {
            int _type = StringLiteral;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\Expr.g:139:5: ( '\"' ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* '\"' )
            // D:\\antlr\\Expr.g:139:8: '\"' ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* '\"'
            {
            match('\"'); 
            // D:\\antlr\\Expr.g:139:12: ( EscapeSequence | ~ ( '\\\\' | '\"' ) )*
            loop4:
            do {
                int alt4=3;
                int LA4_0 = input.LA(1);

                if ( (LA4_0=='\\') ) {
                    alt4=1;
                }
                else if ( ((LA4_0>='\u0000' && LA4_0<='!')||(LA4_0>='#' && LA4_0<='[')||(LA4_0>=']' && LA4_0<='\uFFFF')) ) {
                    alt4=2;
                }


                switch (alt4) {
            	case 1 :
            	    // D:\\antlr\\Expr.g:139:14: EscapeSequence
            	    {
            	    mEscapeSequence(); 

            	    }
            	    break;
            	case 2 :
            	    // D:\\antlr\\Expr.g:139:31: ~ ( '\\\\' | '\"' )
            	    {
            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop4;
                }
            } while (true);

            match('\"'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "StringLiteral"

    // $ANTLR start "NumberLiteral"
    public final void mNumberLiteral() throws RecognitionException {
        try {
            int _type = NumberLiteral;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\Expr.g:141:16: ( '0.' ( Digit )* | DigitNoZero ( Digit )* | DigitNoZero ( Digit )* '.' ( Digit )* )
            int alt9=3;
            alt9 = dfa9.predict(input);
            switch (alt9) {
                case 1 :
                    // D:\\antlr\\Expr.g:141:20: '0.' ( Digit )*
                    {
                    match("0."); 

                    // D:\\antlr\\Expr.g:141:24: ( Digit )*
                    loop5:
                    do {
                        int alt5=2;
                        int LA5_0 = input.LA(1);

                        if ( ((LA5_0>='0' && LA5_0<='9')) ) {
                            alt5=1;
                        }


                        switch (alt5) {
                    	case 1 :
                    	    // D:\\antlr\\Expr.g:141:24: Digit
                    	    {
                    	    mDigit(); 

                    	    }
                    	    break;

                    	default :
                    	    break loop5;
                        }
                    } while (true);


                    }
                    break;
                case 2 :
                    // D:\\antlr\\Expr.g:141:31: DigitNoZero ( Digit )*
                    {
                    mDigitNoZero(); 
                    // D:\\antlr\\Expr.g:141:43: ( Digit )*
                    loop6:
                    do {
                        int alt6=2;
                        int LA6_0 = input.LA(1);

                        if ( ((LA6_0>='0' && LA6_0<='9')) ) {
                            alt6=1;
                        }


                        switch (alt6) {
                    	case 1 :
                    	    // D:\\antlr\\Expr.g:141:43: Digit
                    	    {
                    	    mDigit(); 

                    	    }
                    	    break;

                    	default :
                    	    break loop6;
                        }
                    } while (true);


                    }
                    break;
                case 3 :
                    // D:\\antlr\\Expr.g:141:50: DigitNoZero ( Digit )* '.' ( Digit )*
                    {
                    mDigitNoZero(); 
                    // D:\\antlr\\Expr.g:141:62: ( Digit )*
                    loop7:
                    do {
                        int alt7=2;
                        int LA7_0 = input.LA(1);

                        if ( ((LA7_0>='0' && LA7_0<='9')) ) {
                            alt7=1;
                        }


                        switch (alt7) {
                    	case 1 :
                    	    // D:\\antlr\\Expr.g:141:62: Digit
                    	    {
                    	    mDigit(); 

                    	    }
                    	    break;

                    	default :
                    	    break loop7;
                        }
                    } while (true);

                    match('.'); 
                    // D:\\antlr\\Expr.g:141:71: ( Digit )*
                    loop8:
                    do {
                        int alt8=2;
                        int LA8_0 = input.LA(1);

                        if ( ((LA8_0>='0' && LA8_0<='9')) ) {
                            alt8=1;
                        }


                        switch (alt8) {
                    	case 1 :
                    	    // D:\\antlr\\Expr.g:141:71: Digit
                    	    {
                    	    mDigit(); 

                    	    }
                    	    break;

                    	default :
                    	    break loop8;
                        }
                    } while (true);


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NumberLiteral"

    // $ANTLR start "COLUMNROW"
    public final void mCOLUMNROW() throws RecognitionException {
        try {
            int _type = COLUMNROW;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\Expr.g:143:11: ( ( 'A' .. 'Z' )+ DigitNoZero ( Digit )* )
            // D:\\antlr\\Expr.g:143:13: ( 'A' .. 'Z' )+ DigitNoZero ( Digit )*
            {
            // D:\\antlr\\Expr.g:143:13: ( 'A' .. 'Z' )+
            int cnt10=0;
            loop10:
            do {
                int alt10=2;
                int LA10_0 = input.LA(1);

                if ( ((LA10_0>='A' && LA10_0<='Z')) ) {
                    alt10=1;
                }


                switch (alt10) {
            	case 1 :
            	    // D:\\antlr\\Expr.g:143:14: 'A' .. 'Z'
            	    {
            	    matchRange('A','Z'); 

            	    }
            	    break;

            	default :
            	    if ( cnt10 >= 1 ) break loop10;
                        EarlyExitException eee =
                            new EarlyExitException(10, input);
                        throw eee;
                }
                cnt10++;
            } while (true);

            mDigitNoZero(); 
            // D:\\antlr\\Expr.g:143:37: ( Digit )*
            loop11:
            do {
                int alt11=2;
                int LA11_0 = input.LA(1);

                if ( ((LA11_0>='0' && LA11_0<='9')) ) {
                    alt11=1;
                }


                switch (alt11) {
            	case 1 :
            	    // D:\\antlr\\Expr.g:143:37: Digit
            	    {
            	    mDigit(); 

            	    }
            	    break;

            	default :
            	    break loop11;
                }
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "COLUMNROW"

    // $ANTLR start "FUNCNAME"
    public final void mFUNCNAME() throws RecognitionException {
        try {
            int _type = FUNCNAME;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\Expr.g:145:10: ( ( 'a' .. 'z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' )+ ( Digit )* )
            // D:\\antlr\\Expr.g:145:12: ( 'a' .. 'z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' )+ ( Digit )*
            {
            if ( input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}

            // D:\\antlr\\Expr.g:145:26: ( 'a' .. 'z' | 'A' .. 'Z' | '_' )+
            int cnt12=0;
            loop12:
            do {
                int alt12=2;
                int LA12_0 = input.LA(1);

                if ( ((LA12_0>='A' && LA12_0<='Z')||LA12_0=='_'||(LA12_0>='a' && LA12_0<='z')) ) {
                    alt12=1;
                }


                switch (alt12) {
            	case 1 :
            	    // D:\\antlr\\Expr.g:
            	    {
            	    if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    if ( cnt12 >= 1 ) break loop12;
                        EarlyExitException eee =
                            new EarlyExitException(12, input);
                        throw eee;
                }
                cnt12++;
            } while (true);

            // D:\\antlr\\Expr.g:145:50: ( Digit )*
            loop13:
            do {
                int alt13=2;
                int LA13_0 = input.LA(1);

                if ( ((LA13_0>='0' && LA13_0<='9')) ) {
                    alt13=1;
                }


                switch (alt13) {
            	case 1 :
            	    // D:\\antlr\\Expr.g:145:50: Digit
            	    {
            	    mDigit(); 

            	    }
            	    break;

            	default :
            	    break loop13;
                }
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "FUNCNAME"

    // $ANTLR start "VAR"
    public final void mVAR() throws RecognitionException {
        try {
            int _type = VAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\Expr.g:147:6: ( '$' ( 'a' .. 'z' | 'A' .. 'Z' )+ ( Digit )* )
            // D:\\antlr\\Expr.g:147:8: '$' ( 'a' .. 'z' | 'A' .. 'Z' )+ ( Digit )*
            {
            match('$'); 
            // D:\\antlr\\Expr.g:147:11: ( 'a' .. 'z' | 'A' .. 'Z' )+
            int cnt14=0;
            loop14:
            do {
                int alt14=2;
                int LA14_0 = input.LA(1);

                if ( ((LA14_0>='A' && LA14_0<='Z')||(LA14_0>='a' && LA14_0<='z')) ) {
                    alt14=1;
                }


                switch (alt14) {
            	case 1 :
            	    // D:\\antlr\\Expr.g:
            	    {
            	    if ( (input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='a' && input.LA(1)<='z') ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    if ( cnt14 >= 1 ) break loop14;
                        EarlyExitException eee =
                            new EarlyExitException(14, input);
                        throw eee;
                }
                cnt14++;
            } while (true);

            // D:\\antlr\\Expr.g:147:31: ( Digit )*
            loop15:
            do {
                int alt15=2;
                int LA15_0 = input.LA(1);

                if ( ((LA15_0>='0' && LA15_0<='9')) ) {
                    alt15=1;
                }


                switch (alt15) {
            	case 1 :
            	    // D:\\antlr\\Expr.g:147:31: Digit
            	    {
            	    mDigit(); 

            	    }
            	    break;

            	default :
            	    break loop15;
                }
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "VAR"

    // $ANTLR start "WS"
    public final void mWS() throws RecognitionException {
        try {
            int _type = WS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // D:\\antlr\\Expr.g:151:7: ( ( ' ' | '\\t' )+ )
            // D:\\antlr\\Expr.g:151:11: ( ' ' | '\\t' )+
            {
            // D:\\antlr\\Expr.g:151:11: ( ' ' | '\\t' )+
            int cnt16=0;
            loop16:
            do {
                int alt16=2;
                int LA16_0 = input.LA(1);

                if ( (LA16_0=='\t'||LA16_0==' ') ) {
                    alt16=1;
                }


                switch (alt16) {
            	case 1 :
            	    // D:\\antlr\\Expr.g:
            	    {
            	    if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    if ( cnt16 >= 1 ) break loop16;
                        EarlyExitException eee =
                            new EarlyExitException(16, input);
                        throw eee;
                }
                cnt16++;
            } while (true);

            skip();

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WS"

    public void mTokens() throws RecognitionException {
        // D:\\antlr\\Expr.g:1:8: ( PLUS | SUB | T__19 | T__20 | T__21 | T__22 | T__23 | BooleanLiteral | StringLiteral | NumberLiteral | COLUMNROW | FUNCNAME | VAR | WS )
        int alt17=14;
        alt17 = dfa17.predict(input);
        switch (alt17) {
            case 1 :
                // D:\\antlr\\Expr.g:1:10: PLUS
                {
                mPLUS(); 

                }
                break;
            case 2 :
                // D:\\antlr\\Expr.g:1:15: SUB
                {
                mSUB(); 

                }
                break;
            case 3 :
                // D:\\antlr\\Expr.g:1:19: T__19
                {
                mT__19(); 

                }
                break;
            case 4 :
                // D:\\antlr\\Expr.g:1:25: T__20
                {
                mT__20(); 

                }
                break;
            case 5 :
                // D:\\antlr\\Expr.g:1:31: T__21
                {
                mT__21(); 

                }
                break;
            case 6 :
                // D:\\antlr\\Expr.g:1:37: T__22
                {
                mT__22(); 

                }
                break;
            case 7 :
                // D:\\antlr\\Expr.g:1:43: T__23
                {
                mT__23(); 

                }
                break;
            case 8 :
                // D:\\antlr\\Expr.g:1:49: BooleanLiteral
                {
                mBooleanLiteral(); 

                }
                break;
            case 9 :
                // D:\\antlr\\Expr.g:1:64: StringLiteral
                {
                mStringLiteral(); 

                }
                break;
            case 10 :
                // D:\\antlr\\Expr.g:1:78: NumberLiteral
                {
                mNumberLiteral(); 

                }
                break;
            case 11 :
                // D:\\antlr\\Expr.g:1:92: COLUMNROW
                {
                mCOLUMNROW(); 

                }
                break;
            case 12 :
                // D:\\antlr\\Expr.g:1:102: FUNCNAME
                {
                mFUNCNAME(); 

                }
                break;
            case 13 :
                // D:\\antlr\\Expr.g:1:111: VAR
                {
                mVAR(); 

                }
                break;
            case 14 :
                // D:\\antlr\\Expr.g:1:115: WS
                {
                mWS(); 

                }
                break;

        }

    }


    protected DFA9 dfa9 = new DFA9(this);
    protected DFA17 dfa17 = new DFA17(this);
    static final String DFA9_eotS =
        "\2\uffff\1\3\1\uffff\1\3\1\uffff";
    static final String DFA9_eofS =
        "\6\uffff";
    static final String DFA9_minS =
        "\1\60\1\uffff\1\56\1\uffff\1\56\1\uffff";
    static final String DFA9_maxS =
        "\1\71\1\uffff\1\71\1\uffff\1\71\1\uffff";
    static final String DFA9_acceptS =
        "\1\uffff\1\1\1\uffff\1\2\1\uffff\1\3";
    static final String DFA9_specialS =
        "\6\uffff}>";
    static final String[] DFA9_transitionS = {
            "\1\1\11\2",
            "",
            "\1\5\1\uffff\12\4",
            "",
            "\1\5\1\uffff\12\4",
            ""
    };

    static final short[] DFA9_eot = DFA.unpackEncodedString(DFA9_eotS);
    static final short[] DFA9_eof = DFA.unpackEncodedString(DFA9_eofS);
    static final char[] DFA9_min = DFA.unpackEncodedStringToUnsignedChars(DFA9_minS);
    static final char[] DFA9_max = DFA.unpackEncodedStringToUnsignedChars(DFA9_maxS);
    static final short[] DFA9_accept = DFA.unpackEncodedString(DFA9_acceptS);
    static final short[] DFA9_special = DFA.unpackEncodedString(DFA9_specialS);
    static final short[][] DFA9_transition;

    static {
        int numStates = DFA9_transitionS.length;
        DFA9_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA9_transition[i] = DFA.unpackEncodedString(DFA9_transitionS[i]);
        }
    }

    class DFA9 extends DFA {

        public DFA9(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 9;
            this.eot = DFA9_eot;
            this.eof = DFA9_eof;
            this.min = DFA9_min;
            this.max = DFA9_max;
            this.accept = DFA9_accept;
            this.special = DFA9_special;
            this.transition = DFA9_transition;
        }
        public String getDescription() {
            return "141:1: NumberLiteral : ( '0.' ( Digit )* | DigitNoZero ( Digit )* | DigitNoZero ( Digit )* '.' ( Digit )* );";
        }
    }
    static final String DFA17_eotS =
        "\20\uffff\4\15\1\26\1\15\1\uffff\1\26";
    static final String DFA17_eofS =
        "\30\uffff";
    static final String DFA17_minS =
        "\1\11\7\uffff\2\101\6\uffff\1\165\1\154\1\145\1\163\1\60\1\145"+
        "\1\uffff\1\60";
    static final String DFA17_maxS =
        "\1\172\7\uffff\2\172\6\uffff\1\165\1\154\1\145\1\163\1\172\1\145"+
        "\1\uffff\1\172";
    static final String DFA17_acceptS =
        "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\2\uffff\1\11\1\12\1\13\1\14"+
        "\1\15\1\16\6\uffff\1\10\1\uffff";
    static final String DFA17_specialS =
        "\30\uffff}>";
    static final String[] DFA17_transitionS = {
            "\1\17\26\uffff\1\17\1\uffff\1\12\1\uffff\1\16\3\uffff\1\5\1"+
            "\6\1\3\1\1\1\7\1\2\1\uffff\1\4\12\13\7\uffff\32\14\4\uffff\1"+
            "\15\1\uffff\5\15\1\11\15\15\1\10\6\15",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\32\15\4\uffff\1\15\1\uffff\21\15\1\20\10\15",
            "\32\15\4\uffff\1\15\1\uffff\1\21\31\15",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\22",
            "\1\23",
            "\1\24",
            "\1\25",
            "\12\15\7\uffff\32\15\4\uffff\1\15\1\uffff\32\15",
            "\1\27",
            "",
            "\12\15\7\uffff\32\15\4\uffff\1\15\1\uffff\32\15"
    };

    static final short[] DFA17_eot = DFA.unpackEncodedString(DFA17_eotS);
    static final short[] DFA17_eof = DFA.unpackEncodedString(DFA17_eofS);
    static final char[] DFA17_min = DFA.unpackEncodedStringToUnsignedChars(DFA17_minS);
    static final char[] DFA17_max = DFA.unpackEncodedStringToUnsignedChars(DFA17_maxS);
    static final short[] DFA17_accept = DFA.unpackEncodedString(DFA17_acceptS);
    static final short[] DFA17_special = DFA.unpackEncodedString(DFA17_specialS);
    static final short[][] DFA17_transition;

    static {
        int numStates = DFA17_transitionS.length;
        DFA17_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA17_transition[i] = DFA.unpackEncodedString(DFA17_transitionS[i]);
        }
    }

    class DFA17 extends DFA {

        public DFA17(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 17;
            this.eot = DFA17_eot;
            this.eof = DFA17_eof;
            this.min = DFA17_min;
            this.max = DFA17_max;
            this.accept = DFA17_accept;
            this.special = DFA17_special;
            this.transition = DFA17_transition;
        }
        public String getDescription() {
            return "1:1: Tokens : ( PLUS | SUB | T__19 | T__20 | T__21 | T__22 | T__23 | BooleanLiteral | StringLiteral | NumberLiteral | COLUMNROW | FUNCNAME | VAR | WS );";
        }
    }
 

}